package cn.ai.boot.config.PCF;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class SortKeyExtractor {

    // 定义路径部分的索引
    private enum PathIndex {
        BRANCH(1),
        WELD(2),
        PIPE(3);

        private final int index;

        PathIndex(int index) {
            this.index = index;
        }

        public int getValue() {
            return index;
        }
    }

    // 短路径最小长度 (没有pipe部分)
    private static final int MIN_PATH_LENGTH_SHORT = 3;
    // 长路径最小长度 (有pipe部分)
    private static final int MIN_PATH_LENGTH_LONG = 4;

    /**
     * 从路径中提取排序键
     *
     * @param path 格式为 "/固定值/branch/weld/pipe" 或 "/固定值/branch/weld" 的路径字符串
     * @return 包含可比较元素的列表：[分支编号, 焊接前缀编号, 管道W编号(没有管道时为-1)]
     */
    public static int[] extractSortKey(String path) {
        // 校验输入
        if (Objects.isNull(path) || path.isEmpty()) {
            return createDefaultSortKey();
        }

        // 分割路径
        String[] parts = path.split("/");

        // 校验路径长度
        if (parts.length < MIN_PATH_LENGTH_SHORT) {
            return createDefaultSortKey();
        }

        List<Integer> key = new ArrayList<>(3);

        // 提取分支编号 (格式: branch_数字)
        key.add(parseNumberPart(parts[PathIndex.BRANCH.getValue()], "_", 1));

        // 提取焊接前缀编号 (格式: 数字_...)
        key.add(parsePrefixNumber(parts[PathIndex.WELD.getValue()]));

        // 提取管道编号 (如果存在)
        if (parts.length >= MIN_PATH_LENGTH_LONG) {
            key.add(parsePipeNumber(parts[PathIndex.PIPE.getValue()]));
        } else {
            key.add(-1); // 没有pipe部分，默认为-1
        }

        return key.stream().mapToInt(Integer::intValue).toArray();
    }

    // 解析带有分隔符的部分并提取数字
    private static Integer parseNumberPart(String part, String delimiter, int index) {
        if (Objects.isNull(part) || part.isEmpty()) {
            return Integer.MAX_VALUE;
        }

        String[] subParts = part.split(delimiter);
        if (subParts.length <= index) {
            return Integer.MAX_VALUE;
        }

        return convertToInteger(subParts[index]);
    }

    // 解析前缀数字
    private static Integer parsePrefixNumber(String part) {
        if (Objects.isNull(part) || part.isEmpty()) {
            return Integer.MAX_VALUE;
        }

        int underscoreIndex = part.indexOf('_');
        if (underscoreIndex <= 0) {
            return Integer.MAX_VALUE;
        }

        String prefix = part.substring(0, underscoreIndex);
        return convertToInteger(prefix);
    }

    // 解析管道编号
    private static Integer parsePipeNumber(String part) {
        if (Objects.isNull(part) || part.isEmpty()) {
            return -1;
        }

        if (part.startsWith("W") && part.length() > 1) {
            String wNumber = part.substring(1);
            return convertToInteger(wNumber);
        }

        return -1; // 没有W前缀的情况
    }

    // 字符串转整数，失败时返回默认值
    private static Integer convertToInteger(String str) {
        try {
            return Integer.parseInt(str);
        } catch (NumberFormatException e) {
            return Integer.MAX_VALUE;
        }
    }

    // 创建默认排序键
    private static int[] createDefaultSortKey() {
        return new int[]{Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE};
    }
}